package com.feng.study.demo.lambda;

/**
 * 内部类，类似于实例变量
 * 静态内部类，类似于静态变量
 * 局部内部类，类似于局部变量
 * 匿名内部类
 * 顺便复习一下Lambda表达式
 */

/**
 * 面试题：
 * 24、静态嵌套类(Static Nested Class)和内部类（Inner Class）的不同？
 * 答：Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。
 * 而通常的内部类需要在外部类实例化后才能实例化，
 */
public class InnerClass {
    int age;
    //内部类，类似于实例变量
    class test1{

    }

    static int nums;
    //静态内部类，类似于静态变量
    static class test2{

    }

    void dosome(){
        int id;
        //局部内部类，类似于局部变量
        class test3{

        }
    }
    void doother(){
        test1 tt=new test1();
    }

    public void BBB(){
        test1 t12=new test1();
    }

    public static void AAA(){
        test2 t2=new test2();
//        test1 t1=new test1();  //错误的写法，内部类相当于实例变量，需要先有外部类的实例对象才可以创建
        InnerClass innerClass=new InnerClass();
        test1 t1=innerClass.new test1();
        test1 t11=new InnerClass().new test1();

        int c=nums;
//        int b=age;  //错误的写法
        int b=innerClass.age;
    }

    public static void main(String[] args) {
        //普通调用，没有用匿名内部类，需要实现inter接口，才可以计算加法
        new interTer().sum(new interImpl(),100,200);

        //使用匿名内部类，不需要写inter接口的实现类interImpl，就可以完成计算操作
        new interTer().sum(new inter() {
            @Override
            public int sum(int x, int y) {
                return x+y;
            }
        },100,200);

        //顺便复习一下Lambda表达式，（注意：和前者比较，lambda可以看做是简写了匿名内部类，删掉了接口名，方法名，简化为”(参数)->{实现;}“）
        System.out.println("----------------");
        new interTer().sum((x,y)->{return x+y;},100,200);
    }
}

//匿名内部类探讨
interface inter{
    int sum(int x, int y);
}
class interImpl implements inter{
    @Override
    public int sum(int x, int y) {
        return x+y;
    }
}
class interTer{
    public void sum(inter i,int x,int y){
        int result=i.sum(x,y);
        System.out.println(result);
    }
}
